Macwelt 1/Macwelt DVD 1.toast/Software für Mac-OS X/Entwickler-Tools/netbeans/modules/ext/djava.jar/koala/dynamicjava/interpreter/context/GlobalContext.class

Java Class File | 2000-03-14 | 15.5 KB | 497 lines

package koala.dynamicjava.interpreter.context;

import java.lang.reflect.AccessibleObject;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Member;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import koala.dynamicjava.classinfo.JavaClassInfo;
import koala.dynamicjava.interpreter.ClassLoaderContainer;
import koala.dynamicjava.interpreter.Interpreter;
import koala.dynamicjava.interpreter.NodeProperties;
import koala.dynamicjava.interpreter.TreeCompiler;
import koala.dynamicjava.interpreter.error.CatchedExceptionError;
import koala.dynamicjava.interpreter.error.ExecutionError;
import koala.dynamicjava.interpreter.modifier.FinalVariableModifier;
import koala.dynamicjava.interpreter.modifier.InvalidModifier;
import koala.dynamicjava.interpreter.modifier.LeftHandSideModifier;
import koala.dynamicjava.interpreter.modifier.ObjectFieldModifier;
import koala.dynamicjava.interpreter.modifier.StaticFieldModifier;
import koala.dynamicjava.interpreter.modifier.VariableModifier;
import koala.dynamicjava.interpreter.throwable.ThrownException;
import koala.dynamicjava.tree.ArrayInitializer;
import koala.dynamicjava.tree.ArrayType;
import koala.dynamicjava.tree.ClassAllocation;
import koala.dynamicjava.tree.ClassDeclaration;
import koala.dynamicjava.tree.ConstructorDeclaration;
import koala.dynamicjava.tree.ConstructorInvocation;
import koala.dynamicjava.tree.Expression;
import koala.dynamicjava.tree.FieldDeclaration;
import koala.dynamicjava.tree.FormalParameter;
import koala.dynamicjava.tree.Identifier;
import koala.dynamicjava.tree.IdentifierToken;
import koala.dynamicjava.tree.MethodDeclaration;
import koala.dynamicjava.tree.Node;
import koala.dynamicjava.tree.ObjectFieldAccess;
import koala.dynamicjava.tree.QualifiedName;
import koala.dynamicjava.tree.ReferenceType;
import koala.dynamicjava.tree.SimpleAllocation;
import koala.dynamicjava.tree.SimpleAssignExpression;
import koala.dynamicjava.tree.StaticFieldAccess;
import koala.dynamicjava.tree.StringLiteral;
import koala.dynamicjava.tree.SuperFieldAccess;
import koala.dynamicjava.tree.TreeUtilities;
import koala.dynamicjava.tree.TypeDeclaration;
import koala.dynamicjava.tree.TypeExpression;
import koala.dynamicjava.util.AmbiguousFieldException;
import koala.dynamicjava.util.BufferedImportationManager;
import koala.dynamicjava.util.ImportationManager;
import koala.dynamicjava.util.ReflectionUtilities;

public class GlobalContext extends VariableContext implements Context {
   protected static final ReferenceType CLASS_TYPE = new ReferenceType("java.lang.Class");
   protected static final ReferenceType MAP_TYPE = new ReferenceType("java.util.Map");
   protected static final ReferenceType OBJECT_TYPE = new ReferenceType("java.lang.Object");
   protected static final ArrayType OBJECT_ARRAY_ARRAY;
   protected static final TypeExpression OBJECT_CLASS;
   protected static final String LOCALS_NAME = "local$Variables$Reference$0";
   protected static final FieldDeclaration LOCALS;
   protected static int classCount;
   protected ImportationManager importationManager;
   protected Interpreter interpreter;
   protected ClassLoader classLoader;
   protected ClassLoaderContainer clc;
   protected List functions = new LinkedList();
   // $FF: synthetic field
   private static Class class$Ljava$lang$Object;
   // $FF: synthetic field
   private static Class class$Ljava$util$Map;

   public void setAdditionalClassLoaderContainer(ClassLoaderContainer var1) {
      this.clc = var1;
   }

   protected ClassLoader getAdditionalClassLoader() {
      return this.clc != null ? this.clc.getClassLoader() : null;
   }

   public void setFunctions(List var1) {
      this.functions = var1;
   }

   public List getFunctions() {
      return this.functions;
   }

   public Interpreter getInterpreter() {
      return this.interpreter;
   }

   public ImportationManager getImportationManager() {
      return this.importationManager;
   }

   public void setImportationManager(ImportationManager var1) {
      this.importationManager = var1;
   }

   public boolean exists(String var1) {
      return this.isDefined(var1) || this.classExists(var1);
   }

   public boolean classExists(String var1) {
      boolean var2 = false;
      ImportationManager var10000 = this.importationManager;
      PseudoClassLoader var10001 = new PseudoClassLoader;
      if (this == null) {
         throw null;
      } else {
         var10001.<init>(this);
         var10000.setClassLoader(var10001);

         try {
            this.lookupClass(var1);
            var2 = true;
         } catch (ClassNotFoundException var10) {
         } catch (PseudoError var11) {
            var2 = true;
         } finally {
            if (this.classLoader == null) {
               this.importationManager.setClassLoader(this.interpreter.getClassLoader());
            } else {
               this.importationManager.setClassLoader(this.classLoader);
            }

         }

         return var2;
      }
   }

   public void defineFunction(MethodDeclaration var1) {
      this.functions.add(0, var1);
   }

   public void defineClass(TypeDeclaration var1) {
      (new TreeCompiler(this.interpreter)).compileTree(this, var1);
   }

   public boolean isDefined(String var1) {
      return ((VariableContext)this).isDefinedVariable(var1);
   }

   public void setCurrentPackage(String var1) {
      this.importationManager.setCurrentPackage(var1);
   }

   public String getCurrentPackage() {
      return this.importationManager.getCurrentPackage();
   }

   public void declarePackageImport(String var1) {
      this.importationManager.declarePackageImport(var1);
   }

   public void declareClassImport(String var1) throws ClassNotFoundException {
      ImportationManager var10000 = this.importationManager;
      PseudoClassLoader var10001 = new PseudoClassLoader;
      if (this == null) {
         throw null;
      } else {
         var10001.<init>(this);
         var10000.setClassLoader(var10001);

         try {
            this.importationManager.declareClassImport(var1);
         } catch (PseudoError var7) {
         } finally {
            if (this.classLoader == null) {
               this.importationManager.setClassLoader(this.interpreter.getClassLoader());
            } else {
               this.importationManager.setClassLoader(this.classLoader);
            }

         }

      }
   }

   public Node getDefaultQualifier(Node var1) {
      return this.getDefaultQualifier(var1, "");
   }

   public Node getDefaultQualifier(Node var1, String var2) {
      return null;
   }

   public LeftHandSideModifier getModifier(QualifiedName var1) {
      return (LeftHandSideModifier)(((VariableContext)this).isFinal(var1.getRepresentation()) ? new FinalVariableModifier(var1, NodeProperties.getType(var1)) : new VariableModifier(var1, NodeProperties.getType(var1)));
   }

   public LeftHandSideModifier getModifier(ObjectFieldAccess var1) {
      Field var2 = (Field)var1.getProperty("field");
      return (LeftHandSideModifier)(var2.isAccessible() ? new ObjectFieldModifier(var2, var1) : new InvalidModifier(var1));
   }

   public LeftHandSideModifier getModifier(StaticFieldAccess var1) {
      Field var2 = (Field)var1.getProperty("field");
      return (LeftHandSideModifier)(var2.isAccessible() ? new StaticFieldModifier(var2, var1) : new InvalidModifier(var1));
   }

   public LeftHandSideModifier getModifier(SuperFieldAccess var1) {
      throw new IllegalStateException("internal.error");
   }

   public Object getHiddenArgument() {
      return null;
   }

   public Expression createName(Node var1, IdentifierToken var2) {
      if (!this.isDefined(var2.image())) {
         throw new IllegalStateException();
      } else {
         LinkedList var3 = new LinkedList();
         var3.add(var2);
         return new QualifiedName(var3);
      }
   }

   public Class lookupClass(String var1) throws ClassNotFoundException {
      return this.importationManager.lookupClass(var1, (String)null);
   }

   public Class lookupClass(String var1, String var2) throws ClassNotFoundException {
      return this.importationManager.lookupClass(var1, var2);
   }

   public Class setProperties(SimpleAllocation var1, Class var2, Class[] var3) {
      Object var4 = null;

      try {
         var7 = this.lookupConstructor(var2, var3);
      } catch (Exception var6) {
         throw new CatchedExceptionError(var6, var1);
      }

      var1.setProperty("type", var2);
      var1.setProperty("constructor", var7);
      return var2;
   }

   public Class setProperties(ClassAllocation var1, Class var2, Class[] var3, List var4) {
      String var5 = "TopLevel" + "$" + classCount++;
      FieldDeclaration var6 = new FieldDeclaration(25, CLASS_TYPE, "declaring$Class$Reference$0", OBJECT_CLASS);
      var4.add(var6);
      var4.add(LOCALS);
      var6 = new FieldDeclaration(25, OBJECT_ARRAY_ARRAY, "local$Variables$Class$0", this.createClassArrayInitializer());
      var4.add(var6);
      LinkedList var8 = new LinkedList();
      LinkedList var9 = new LinkedList();
      var8.add(new FormalParameter(false, MAP_TYPE, "param$0"));
      LinkedList var10 = new LinkedList();

      for(int var11 = 0; var11 < var3.length; ++var11) {
         var8.add(new FormalParameter(false, TreeUtilities.classToType(var3[var11]), "param$" + (var11 + 1)));
         LinkedList var12 = new LinkedList();
         var12.add(new Identifier("param$" + (var11 + 1)));
         var10.add(new QualifiedName(var12));
      }

      ConstructorInvocation var23 = null;
      if (var10.size() > 0) {
         var23 = new ConstructorInvocation((Expression)null, var10, true);
      }

      LinkedList var24 = new LinkedList();
      var24.add(new Identifier("local$Variables$Reference$0"));
      LinkedList var13 = new LinkedList();
      var13.add(new Identifier("param$0"));
      var9.add(new SimpleAssignExpression(new QualifiedName(var24), new QualifiedName(var13)));
      ConstructorDeclaration var7 = new ConstructorDeclaration(1, var5, var8, new LinkedList(), var23, var9);
      var4.add(var7);
      LinkedList var14 = null;
      LinkedList var15 = null;
      if (var2.isInterface()) {
         var15 = new LinkedList();
         LinkedList var16 = new LinkedList();
         var16.add(new Identifier(var2.getName()));
         var15.add(var16);
      } else {
         var14 = new LinkedList();
         var14.add(new Identifier(var2.getName()));
      }

      ClassDeclaration var25 = new ClassDeclaration(1, var5, var14, var15, var4);
      ((TypeDeclaration)var25).setProperty("anonymousDeclaringClass", new JavaClassInfo(class$Ljava$lang$Object != null ? class$Ljava$lang$Object : (class$Ljava$lang$Object = class$("java.lang.Object"))));
      Class var17 = (new TreeCompiler(this.interpreter)).compileTree(this, var25);
      Class[] var18 = new Class[var3.length + 1];
      var18[0] = class$Ljava$util$Map != null ? class$Ljava$util$Map : (class$Ljava$util$Map = class$("java.util.Map"));

      for(int var19 = 1; var19 < var18.length; ++var19) {
         var18[var19] = var3[var19 - 1];
      }

      var3 = var18;

      try {
         var1.setProperty("constructor", this.lookupConstructor(var17, var3));
      } catch (NoSuchMethodException var20) {
         var20.printStackTrace();
      }

      var1.setProperty("type", var17);
      return var17;
   }

   protected ArrayInitializer createClassArrayInitializer() {
      LinkedList var1 = new LinkedList();
      ReferenceType var3 = new ReferenceType((class$Ljava$lang$Object != null ? class$Ljava$lang$Object : (class$Ljava$lang$Object = class$("java.lang.Object"))).getName());
      Map var4 = ((VariableContext)this).getConstants();

      for(String var6 : var4.keySet()) {
         LinkedList var7 = new LinkedList();
         var7.add(new StringLiteral('"' + var6 + '"'));
         Class var8 = (Class)var4.get(var6);
         var7.add(new TypeExpression(TreeUtilities.classToType(var8)));
         ArrayInitializer var2 = new ArrayInitializer(var7);
         var2.setElementType(var3);
         var1.add(var2);
      }

      ArrayType var9 = new ArrayType(var3, 1);
      ArrayInitializer var10 = new ArrayInitializer(var1);
      var10.setElementType(var9);
      return var10;
   }

   public Constructor lookupConstructor(Class var1, Class[] var2) throws NoSuchMethodException {
      Constructor var3 = ReflectionUtilities.lookupConstructor(var1, var2);
      this.setAccessFlag(var3);
      return var3;
   }

   public Object invokeConstructor(SimpleAllocation var1, Object[] var2) {
      Constructor var3 = (Constructor)var1.getProperty("constructor");

      try {
         return var3.newInstance(var2);
      } catch (InvocationTargetException var5) {
         if (var5.getTargetException() instanceof Error) {
            throw (Error)var5.getTargetException();
         } else if (var5.getTargetException() instanceof RuntimeException) {
            throw (RuntimeException)var5.getTargetException();
         } else {
            throw new ThrownException(var5.getTargetException());
         }
      } catch (Exception var6) {
         throw new CatchedExceptionError(var6, var1);
      }
   }

   public Object invokeConstructor(ClassAllocation var1, Object[] var2) {
      Constructor var3 = (Constructor)var1.getProperty("constructor");
      Object[] var4 = new Object[var2.length + 1];
      var4[0] = ((VariableContext)this).getConstants();

      for(int var5 = 1; var5 < var4.length; ++var5) {
         var4[var5] = var2[var5 - 1];
      }

      var2 = var4;

      try {
         return var3.newInstance(var2);
      } catch (InvocationTargetException var6) {
         if (var6.getTargetException() instanceof Error) {
            throw (Error)var6.getTargetException();
         } else if (var6.getTargetException() instanceof RuntimeException) {
            throw (RuntimeException)var6.getTargetException();
         } else {
            throw new ThrownException(var6.getTargetException());
         }
      } catch (Exception var7) {
         throw new CatchedExceptionError(var7, var1);
      }
   }

   public Method lookupMethod(Node var1, String var2, Class[] var3) throws NoSuchMethodException {
      Class var4 = NodeProperties.getType(var1);
      Method var5 = ReflectionUtilities.lookupMethod(var4, var2, var3);
      this.setAccessFlag(var5);
      if (var5.getName().equals("clone")) {
         var5.setAccessible(true);
      }

      return var5;
   }

   public MethodDeclaration lookupFunction(String var1, Class[] var2) throws NoSuchFunctionException {
      Iterator var3 = this.functions.iterator();
      LinkedList var4 = new LinkedList();

      while(var3.hasNext()) {
         MethodDeclaration var5 = (MethodDeclaration)var3.next();
         if (var5.getName().equals(var1)) {
            var4.add(var5);
         }
      }

      for(MethodDeclaration var11 : var4) {
         List var6 = var11.getParameters();
         if (var6.size() == var2.length) {
            Class[] var7 = new Class[var6.size()];
            Iterator var8 = var6.iterator();

            for(int var9 = 0; var8.hasNext(); var7[var9++] = NodeProperties.getType((Node)var8.next())) {
            }

            if (ReflectionUtilities.hasCompatibleSignatures(var7, var2)) {
               return var11;
            }
         }
      }

      throw new NoSuchFunctionException(var1);
   }

   public Method lookupSuperMethod(Node var1, String var2, Class[] var3) throws NoSuchMethodException {
      throw new ExecutionError("super.method", var1);
   }

   public Field getField(Class var1, String var2) throws NoSuchFieldException, AmbiguousFieldException {
      Field var3 = ReflectionUtilities.getField(var1, var2);
      this.setAccessFlag(var3);
      return var3;
   }

   public Field getSuperField(Node var1, String var2) throws NoSuchFieldException, AmbiguousFieldException {
      throw new ExecutionError("super.field", var1);
   }

   protected void setAccessFlag(Member var1) {
      int var2 = var1.getModifiers();
      Class var3 = var1.getDeclaringClass();
      int var4 = var3.getModifiers();
      String var5 = this.importationManager.getCurrentPackage();
      String var6 = this.getPackageName(var3);
      boolean var7 = var5.equals(var6);
      if (Modifier.isPublic(var4) || var7) {
         if (Modifier.isPublic(var2)) {
            ((AccessibleObject)var1).setAccessible(true);
         } else if (Modifier.isProtected(var2)) {
            if (var7) {
               ((AccessibleObject)var1).setAccessible(true);
            }
         } else if (!Modifier.isPrivate(var2) && var7) {
            ((AccessibleObject)var1).setAccessible(true);
         }
      }

   }

   protected String getPackageName(Class var1) {
      String var2 = var1.getName();
      int var3 = var2.lastIndexOf(46);
      return var3 == -1 ? "" : var2.substring(0, var3);
   }

   // $FF: synthetic method
   static Class class$(String var0) {
      try {
         return Class.forName(var0);
      } catch (ClassNotFoundException var2) {
         throw new NoClassDefFoundError(((Throwable)var2).getMessage());
      }
   }

   public GlobalContext(Interpreter var1) {
      this.importationManager = new BufferedImportationManager(var1.getClassLoader());
      this.interpreter = var1;
   }

   public GlobalContext(Interpreter var1, ClassLoader var2) {
      this.importationManager = new BufferedImportationManager(var2);
      this.interpreter = var1;
      this.classLoader = var2;
   }

   public GlobalContext(Interpreter var1, Set var2) {
      super(var2);
      this.interpreter = var1;
   }

   static {
      OBJECT_ARRAY_ARRAY = new ArrayType(OBJECT_TYPE, 2);
      OBJECT_CLASS = new TypeExpression(OBJECT_TYPE);
      LOCALS = new FieldDeclaration(1, MAP_TYPE, "local$Variables$Reference$0", (Expression)null);
      classCount = 0;
   }
}